package com.zxw.java基础.线程.创建线程的方式;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.*;

/**
 * @projectName: util-cloud
 * @package: com.zxw.java基础.线程.创建线程的方式
 * @className: CreateThread
 * @author: zhangxuewei
 * @description: TODO
 * @date: 2023/10/31 13:39
 * @version: 1.0
 */
public class CreateThreadExample {


}

// 1、实现thread重写run方法
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("MyThread is running");
    }

    public static void main(String[] args) {
        // 创建并启动线程
        MyThread thread = new MyThread();
        thread.start();
    }
}

// 2、实现runnable接口的run方法
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("MyRunnable is running");
    }

    public static void main(String[] args) {
        // 创建并启动线程
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

// 3、使用lambda表达式或者匿名内部类
class newT {
    public static void main(String[] args) {
        // 使用Lambda表达式创建线程
        Thread thread1 = new Thread(() -> {
            // 线程执行的代码逻辑
            System.out.println("Lambda Thread is running");
        });
        thread1.start();

        // 使用匿名内部类创建线程
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程执行的代码逻辑
                System.out.println("Anonymous Thread is running");
            }
        });
        thread2.start();
    }
}

// 4、使用Callable和Future：Callable接口类似于Runnable接口，但是它可以返回一个结果，并且可以通过Future对象来获取执行结果
class MyCallable implements Callable<String> {
    @Override
    public String call() {
        // 线程执行的代码逻辑
        return "MyCallable is running";
    }

    public static void main(String[] args) {
        // 创建并启动线程
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        // 获取线程执行结果
        try {
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

// 5、使用线程池：使用线程池可以管理和复用线程，提高线程的执行效率。可以使用Java提供的ExecutorService接口及其实现类来创建线程池。
class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建固定大小的线程池

        for (int i = 0; i < 10; i++) {
            Runnable task = () -> {
                // 线程执行的代码逻辑
                System.out.println("Thread is running");
            };
            executorService.submit(task); // 提交任务给线程池执行
        }

        executorService.shutdown(); // 关闭线程池
    }
}

// 6、使用定时器：可以使用Java提供的Timer类或ScheduledExecutorService接口来创建定时任务，让线程在指定的时间间隔内重复执行
class TimerExample {
    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // 线程执行的代码逻辑
                System.out.println("Timer thread is running");
            }
        };

        Timer timer = new Timer();
        timer.schedule(task, 1000, 2000); // 延迟1秒后开始执行，并每隔2秒重复执行
    }
}

